gesturesingle: Add missing documentation

gesture: Add missing documentation

eventcontroller: Add missing documentation

enums: Add missing docs to controller/gesture enums

Remove GtkPressAndHold

This is replaced by GtkGestureLongPress, and all its callers have
been updated to use the replacement.

enums: Document GtkPropagationPhase

spinbutton: increase/decrease value on upwards/downwards touch swipes

This is somewhat analogous to scroll events on pointer devices, the
greater the velocity, the faster the spinbutton spins.

Add GtkGesturePan

This gesture reports events on horizontal/vertical panning gestures.

range: Replace GtkPressAndHold with GtkGestureLongPress

swipe: Add function to retrieve the current velocity

This can be used to fetch the current velocity on update(), as opposed
to swipe() which happens after the sequence is finished.

colorswatch: Replace GtkPressAndHold

GtkGestureLongPress and GtkGestureMultiPress are both used
to replace it.

colorscale: Replace GtkPressAndHold with GtkLongPressGesture

colorplane: Replace GtkPressAndHold with GtkLongPressGesture

entry: Don't show text handles too eagerly on button press

Instead do so on button release, or after text selection dragging
starts.

longpress: Ensure check() happens after cancel()

And delegate on GtkGesture::check(), it does deal better with
extra fleeting touches.

longpress: fix reentrancy on ::reset()

gesturemultipress: fix reentrancy on ::reset()

gesturesingle: check the current sequence before resetting the pressed button

scrolledwindow: update to gesture widget-level API changes

window: update to gesture widget-level API changes

treeview: update to gesture widget-level API changes

drag: remove unused #define

eventcontroller: Add documentation blurb

dnd: Update to gesture widget-level API changes

demo: Update to gesture widget-level API changes

widget: refactor gesture integration

Listen for notify::sequence-state-changed on the controller, so the
only way to manipulate a sequence state are gtk_gesture_set_sequence_state()
and gtk_gesture_set_state().

Also, make use of gesture groups, so the sequence state is set at once
on all gestures pertaining to a single group. Within a widget, if a sequence
is claimed on one group, it is made to be denied on every other group.

gesture: Add grouping API

This API eliminates the need for overriding
GtkWidget::sequence-state-changed virtually everywhere. Grouped
gestures share common states for a same GdkEventSequence, so the
state of sequences stay in sync across those.

gesture: Add gtk_gesture_set_state() helper.

This function sets the state on all sequences where it actually
can, just a helper function to avoid iterating over sequences
yourself.

gesture: emit the current state on ::sequence-state-changed

gesture: group continue conditions together

gesture: return TRUE if the sequence state was already set

gesture: fix compiler warning

gesture: ignore events if now widget window was found

eventcontroller: Add propagation-phase property

This is so we don't have to specify the capture phase for
every controller. The default "bubble" value will be sane
on most situations.

treeview: remove superfluous GTK+ grabs

textview: remove superfluous GTK+ grabs

iconview: remove superfluous GTK+ grabs

combobox: remove superfluous GTK+ grabs

cellrendereraccel: remove superfluous GTK+ grabs

Revert "gtk: Remove propagation limit of captured events on the grab widget"

This reverts commit 6511f411955adba4f960b8b07d39b93785afe33e.

longpress: Use xsettings to determine long press duration

GtkSettings::gtk-long-press-time is used to this effect.

settings: Add gtk-long-press-time setting

This setting determines the duration of a button/touch press to
be considered a long press.

window: Use gestures for window moving/resizing

A multipress gesture is used to control all this, replacing
single/double click custom code, and triggering window dragging
when the multipress is stopped, yet active (ie. the sequence remains
pressed).

treeview: Use multipress gesture for row activation

Replace custom double click detection with multipress gesture

dnd: Use GtkGestureDrag to initiate DnD

This gesture is used by gtk_drag_source_set() to determine
whether dragging moved past the threshold. The gesture events
are handled via the usual ::event callbacks, so we don't mess
up with callers expecting that to happen in a signal handler.

If the sequence gets claimed somewhere else in the event widget
stack, the DnD gesture will be cancelled.

scrolledwindow: Ensure the dragging sequence gets denied if more touches come in

This allows children to receive an emulated press, and handle it together with
the new touch that made the scrolledwindow sequence denied.

scrolledwindow: Fix overshoot coordinates

With gtk_gesture_get_point() returning events in
gtk_event_controller_get_widget() coordinates, we no longer need
to compensate for the overshoot here.

widget: Add gtk_widget_set_gesture_state()

This helper function ensures the state is propagated for
all the active sequences in the given gesture.

widget: Improve button press emulation on sequence denied

Ensure that state being set on pointer emulating touches actually
gets propagated properly on widgets with gestures that only handle
pointer events.

swipe: Dont emit swipe() if the gesture was denied rather than finished

drag: Make API offsets based

It is generally more useful to get offsets right away,
than having to calculate those from the start point.

scrolledwindow: Use GtkGestureSingle API

scrolledwindow: Update gesture API change.

demo: Update to gesture API change

widget: Reset gestures on grab-notify

If it is determined that the gesture will stop receiving
events, reset the gesture altogether.

widget: Make helper gesture API take GtkGestures

GtkEventController may be certainly useful to keep event
handling self-contained in other places than gestures, but
the current widget API is highly related to gestures, so
just using GtkGesture as the argument there will be quite
more convenient. The other places where GtkEventController
make sense as a base object will better provide their own
hooks.

Add: GTK_PHASE_NONE value to GtkCapturePhase.

Gestures attached with this phase will expect callers to have it
receive events through gtk_event_controller_handle_event(), but
the gesture will still be notified of sequence state changes,
grabs, etc...

gesture: check the gesture after denying a sequence.

So the gesture emits end() timely.

gesture: Offer always coordinates in the gesture widget coordinate space

Translate events meant for other widgets/windows, so gtk_gesture_get_point()
always returns coordinates based on the gtk_event_controller_get_widget()
allocation.

multipress: Remove unused signal argument

swipe: Make a subclass of GtkGestureSingle

drag: Make a subclass of GtkGestureSingle

multipress: Make a subclass of GtkGestureSingle

The redundant API has been removed here.

longpress: Make a subclass of GtkGestureSingle

the redundant API here has been removed.

gesture: Only recognize gestures with as many interacting touches as those handled

If a gesture has denied sequences (so those are presumably handled above/below
the widget), it shouldn't attempt to handle extra touches, even if those end
up matching the expected number of touches.

gesture: Limit API calls to non-denied sequences

Gestures do track those internally, but information about those
shouldn't be leaked on calls.

gesture: Require BUTTON_PRESS/TOUCH_BEGIN for sequences to be initiated.

Gestures should always receive one of such events in order to be activated,
and the propagation mechanism will ensure they do so if the original event
was caught up the widget hierarchy by another gesture that is now declining
the sequence.

gesture: Only track non denied sequences in get_last_updated_sequence()

gesture: cancel all ongoing sequences on reset()

gesture: Skip non-device events early.

gesture: Add gtk_gesture_[sg]et_window()

This can be used to restrict a gesture to an specific GdkWindow,
all events will be checked to happen on/within that window.

docs: Add GtkGestureSingle to docs

gesture: Remove the touch-only property

This is handled in GtkGestureSingle.

Add GtkGestureSingle

This is a GtkGesture subclass, specific to single-touch (or
mouse operated) gestures.

...and add the right include instead

Remove a doubled line

scrolledwindow: Use gesture button/touch press synthesization

This makes scrolled window fully compatible again wrt the
GtkScrolledWindow::capture-button-press property.

widget: Propagate touch/button press events when a sequence is denied

If the captured touch begin or button press event have been consumed
for the given sequence, propagate it upwards if the sequence goes from
claimed to denied, so the widgets on the way to the event widget receive
a coherent event stream now that they're going to receive events.

gesture: Add private getter to know whether a touch begin was handled

If GDK_TOUCH_BEGIN was handled/consumed for a sequence, or GDK_BUTTON_PRESS was
handled for the mouse gesture, this function will return TRUE.

widget: Implement hierarchy-level mechanism to claim/deny sequences

The policy of sequence states has been made tighter on GtkGesture,
so gestures can never return to a "none" state, nor get out of a
"denied" state, a "claimed" sequence can go "denied" though.

The helper API at the widget level will first emit
GtkWidget::sequence-state-changed on the called widget, and then
notify through the same signal to every other widget in the captured
event chain. So the effect of that signal is twofold, on one hand
it lets the original widget set the state on its attached controllers,
and on the other hand it lets the other widgets freely adapt to the
sequence state changing elsewhere in the event widget chain.

By default, that signal updates every controller on the first usecase,
and propagates the default gesture policy to every other widget in the
chain on the second. This means that, by default:

1) Sequences start out on the "none" state, and get propagated through
   all the event widget chain.
2) If a widget in the chain denies the sequence, all other widgets are
   unaffected.
3) If a widget in the chain claims the sequence, then:
  3.1) Every widget below the claiming widget (ie. towards the event widget)
       will get the sequence cancelled.
  3.2) Every widget above the claiming widget that had the sequence as "none"
       will remain as such, if it was claimed it will go denied, but that should
       rarely happen.

This behavior can be tweaked through the GtkWidget::sequence-state-changed and
GtkGesture::event-handled vmethods, although this should be very rarely done.

docs: Add GtkWidget gesture functions

scrolledwindow: port to GtkGesture

The kinetic scrolling feature is now implemented using a
GtkGestureDrag and a GtkGestureSwipe, plus a GtkGestureLongPress
in order to denying the sequence, so it is possibly handled
underneath.

widget: Add widget-level handling of touch sequence state.

These functions ATM do nothing but proxying the controller(s) state
with the given sequence.

widget: Hook GtkEventController to widget event processing.

A controller can be optionally hooked on the capture or the bubble
phase, so the controller will automatically receive and handle events
as they arrive without further interaction.

gtk: Remove propagation limit of captured events on the grab widget

Now, all captured events run from the toplevel to the deepmost widget,
regardless of GTK+ grabs. This makes captured events more useful to
event controllers if used together in the hierarchy with widgets doing
old fashioned event handling and GTK+ grabs.

gtk-demo: Add simple gestures demo

hook GtkGesture* into docs generation

Add GtkGestureMultiPress

This gesture handles any number of clicks, ensuring multiple presses
stay within thresholds and timeouts. When anything of that happens,
the gesture is reset and press count starts from 1 again.

Optionally, the gesture can be given a rectangle, used in in presses > 1
to ensure the consecutive presses happen on user imposed areas.

Add GtkGestureDrag

This gesture interprets and reports drags as an offset to the drag
start point.

Add GtkGestureZoom

This gesture interprets and reports relative scale differences when fed
with events from two different GdkEventSequences.

Add GtkGestureRotate

This gesture implementation recognizes rotations when fed with
events from two different GdkEventSequences

Add GtkGestureSwipe

This gesture implementation recognices swipes on any direction.
The "swipe" signal has the X/Y velocity vector components, so
those can be used for direction guessing and velocity thresholds.

Add GtkGestureLongPress

This gesture interprets long presses with variable delays
and thresholds

Add GtkGesture

This a more specific abstract type that handles one or multiple
streams of pointer/touch events.

Add GtkEventController

This is a basic abstract type that handles GdkEvents.

themingbackground: Outset shadows require border box

They are drawn relative to the border box, not relative to the padding
box.

css: Make getter function a real getter

Initialize the passed-in value, don't treat it as an in-out parameter.

testsuite: Add more icon names

These were found by looking over the GTK+ sources and ui files.

Add more icons to check-icon-names

These are icons which are used as GtkArrow replacement, and
icons used for the volume button.

testsuite: Run reftests with GTK_DEBUG=icontheme

This will hopefully help to track down some hard-to-squash
failures that only happen in gnome-continuous.